package com.ruoyi.common.utils.file;

import cn.hutool.core.img.Img;
import cn.hutool.core.img.ImgUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.NumberUtil;
import com.ruoyi.common.config.TuodayunConfig;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.utils.StrUtil;
import org.apache.poi.util.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * 图片处理工具类
 *
 * @author ruoyi
 */
public class ImgUtils extends ImgUtil
{
    private static final Logger log = LoggerFactory.getLogger(ImgUtils.class);

    public static final String BASE64_STARTWITH = "data:image/png;base64,";

    public static byte[] getImage(String imagePath)
    {
        InputStream is = getFile(imagePath);
        try
        {
            return IOUtils.toByteArray(is);
        }
        catch (Exception e)
        {
            log.error("图片加载异常 {}", e);
            return null;
        }
        finally
        {
            IOUtils.closeQuietly(is);
        }
    }

    public static InputStream getFile(String imagePath)
    {
        try
        {
            byte[] result = readFile(imagePath);
            result = Arrays.copyOf(result, result.length);
            return new ByteArrayInputStream(result);
        }
        catch (Exception e)
        {
            log.error("获取图片异常 {}", e);
        }
        return null;
    }

    /**
     * 读取文件为字节数据
     * 
     * @return 字节数据
     */
    public static byte[] readFile(String url)
    {
        InputStream in = null;
        ByteArrayOutputStream baos = null;
        try
        {
            if (url.startsWith("http")||url.startsWith("https"))
            {
                // 网络地址
                URL urlObj = new URL(url);
                URLConnection urlConnection = urlObj.openConnection();
                urlConnection.setConnectTimeout(30 * 1000);
                urlConnection.setReadTimeout(60 * 1000);
                urlConnection.setDoInput(true);
                in = urlConnection.getInputStream();
            }
            else
            {
                // 本机地址
                String localPath = TuodayunConfig.getProfile();
                String downloadPath = localPath + StrUtil.subAfter(url, Constants.RESOURCE_PREFIX,false);
                in = new FileInputStream(downloadPath);
            }
            return IoUtil.readBytes(in);
        }
        catch (Exception e)
        {
            log.error("获取文件路径异常 {}", e);
            return null;
        }
        finally
        {
            IoUtil.close(in);
            IoUtil.close(baos);
        }
    }

    /**
     * 图像切割（指定切片的行数和列数）
     *
     * @param srcImage 源图像
     * @param  imageType 目标图片类型，例如jpg或png等
     * @param rows     目标切片行数。默认2，必须是范围 [1, 20] 之内
     * @param cols     目标切片列数。默认2，必须是范围 [1, 20] 之内
     */
    public static java.util.List<BufferedImage> sliceByRowsAndCols(Image srcImage,String imageType, int rows, int cols) {
        if (rows <= 0 || rows > 20) {
            rows = 2; // 切片行数
        }
        if (cols <= 0 || cols > 20) {
            cols = 2; // 切片列数
        }
        // 读取源图像
        BufferedImage bi;
        if (srcImage instanceof  BufferedImage){
            bi = (BufferedImage) srcImage;
        }else {
            bi = toBufferedImage(srcImage);
        }
        int srcWidth = bi.getWidth(); // 源图宽度
        int srcHeight = bi.getHeight(); // 源图高度

        int destWidth = NumberUtil.partValue(srcWidth, cols); // 每张切片的宽度
        int destHeight = NumberUtil.partValue(srcHeight, rows); // 每张切片的高度
        java.util.List<BufferedImage> list = new ArrayList<>();
        // 循环建立切片
        BufferedImage tag;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                Image cut = cut(bi, new Rectangle(j * destWidth, i * destHeight, destWidth, destHeight));
                tag = toBufferedImage(cut,imageType);
               list.add(tag);
            }
        }
        return list;
    }

    /**
     * 给图片添加图片水印<br>
     * 此方法并不关闭流
     *
     * @param srcImage 源图像流
     * @param pressImg 水印图片，可以使用{@link ImageIO#read(File)}方法读取文件
     * @param x        修正值。 默认在中间，偏移量相对于中间偏移
     * @param y        修正值。 默认在中间，偏移量相对于中间偏移
     * @param positionBaseCenter  是否以中心为原始坐标
     * @param alpha    透明度：alpha 必须是范围 [0.0, 1.0] 之内（包含边界值）的一个浮点数字
     * @return 结果图片
     */
    public static Image pressImage(Image srcImage, Image pressImg, int x, int y, boolean positionBaseCenter,float alpha) {
        return Img.from(srcImage).setPositionBaseCentre(positionBaseCenter).pressImage(pressImg, x, y, alpha).getImg();
    }


}
